██████╗ ███████╗████████╗██╗██████╗ ███████╗██████╗ ██╗ █████╗
██╔══██╗██╔════╝╚══██╔══╝██║██╔══██╗██╔════╝██╔══██╗██║██╔══██╗
██████╔╝█████╗ ██║ ██║██████╔╝█████╗ ██║ ██║██║███████║
██╔══██╗██╔══╝ ██║ ██║██╔═══╝ ██╔══╝ ██║ ██║██║██╔══██║
██║ ██║███████╗ ██║ ██║██║ ███████╗██████╔╝██║██║ ██║
╚═╝ ╚═╝╚══════╝ ╚═╝ ╚═╝╚═╝ ╚══════╝╚═════╝ ╚═╝╚═╝ ╚═╝
- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b
¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
Scanf
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
top
mwbqscanf (abbreviazione dell'inglese scan formatted) è una mwbgfunzione che viene implementata in diversi mwbwlinguaggi di programmazione. Viene utilizzata per l'inserimento di dati formattati (caratteri e numeri). Da essa derivano inoltre altre funzioni, tra le cui più citate mwcafscanf e mwcqsscanf.
Ha origine dal mwcwlinguaggio C dove è inclusa nella libreria mwdamwdqstdio.h, ma queste funzioni sono precedenti a Ccite-ref-1[1] e possiedono altri nomi, come ad esempio mwegreadf in mwewALGOL 68.
Contents
• Storia
• Utilizzo
• Sintassi
• fscanf
• sscanf
• Note
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
Storia
Utilizzo
La funzione ha il seguente mwiaprototipo:
int scanf(const char *format, ...);
int scanf(const char * restrict format, ...);
La funzione legge dei caratteri dal canale mwtastandard di input (stdincite-ref-4[4]), solitamente la mwuqtastiera, li converte secondo le specifiche di formattazione fornite dall'argomento mwugformat e memorizza i valori ottenuti negli argomenti seguenti in concordanza del mwuwtipo di dato richiesto.cite-ref-5[5] La funzione si ferma quando esaurisce la propria stringa di formattazione o quando alcuni dati in ingresso non soddisfano le specifiche di conversione. Il valore restituito è un numero intero che indica quanti valori sono stati estratti correttamente: negativo se si è verificato un errore, positivo se c'è stata una lettura e in particolare 0 (zero) se non è stata fatta alcuna assegnazione perché il primo carattere letto non è conforme alla prima specifica della stringa di formato.
Similarmente alla funzione mwwqprintf, il mwwg... sta ad indicare che si tratti di una mwwwfunzione variadica (che può assumere un numero variabile di parametri).
Sintassi
La sintassi generica da seguire per chiamare la funzione è:
scanf (tipo, &arg);
Da notare come si debba fornire l'indirizzo di memoria di mwawarg (tramite l'mwbaoperatore unario mwbq&) in cui verranno memorizzati i dati. A ciò fa però eccezione il definitore mwbg%s perché, in quanto mwbwarray di caratteri, è già un mwcapuntatore: nella dichiarazione di un array infatti, viene memorizzato l'indirizzo di memoria del primo elemento che lo compone, pertanto, dato ad esempio un vettore mwcqstrvet[37], le due espressioni mwcg*strvet e mwcwstrvet[0] sono equivalenti.cite-ref-6[6]
Qui di seguito è riportato un esempio in C
#include <stdio.h>
/* Libreria standard per l'I/O */
int main() {
int n;
printf("Inserisci il valore di N: ");
scanf("%d", &n);
printf("N al quadrato è uguale a %d\n", n*n);
return 0;
}
Nell'esempio proposto viene richiesto all'utente un numero intero e viene calcolato il quadrato di tale numero.
La funzione mwuqscanf ha lo scopo di rilevare quanto immesso dall'utente tramite la tastiera, convertirlo in un numero intero e memorizzarne il risultato nella variabile mwugn.
La lettura si blocca appena incontra un carattere non conforme a quello definito dal definitore di formato.
Quindi, in questo esempio, fornendo un input del tipo mwvq435 9483 9342 oppure mwvg435ute, si otterrebbe in entrambi i casi mwvw435*435 come output (a schermo), lasciando nel mwwabuffer di memoria il resto della stringa, che potrebbe essere letta da un'altra funzione o dalla stessa, se inserita in un ciclo apposito. Bisogna pertanto prestare attenzione a questo fattore perché potrebbe creare incongruenze con le altre funzioni che accederebbero successivamente al buffer.
L'argomento format
L'argomento mwwwformat è una stringa che specifica l'interpretazione dell'input e può contenere una o più di:
• Spazi vuoti: vuoto, tabulazioni mwxg\t o nuova riga mwxw\n e mwya\r e anche le rispettive traduzioni numeriche mwyqASCII, compreso lo mwyg\0 (zero di fine stringa). Un carattere di spazio vuoto comporta che mwywn legga, ma non memorizzi, tutti i caratteri di spazio vuoti consecutivi nell'input fino al successivo carattere diverso da uno spazio vuoto;
• Caratteri diversi da uno spazio vuoto, ad eccezione del segno di percentuale (mwzq%). Un carattere diverso da uno spazio vuoto comporta che mwzgscanf legga, ma non memorizzi, un carattere diverso da uno spazio vuoto corrispondente. Se il carattere successivo nel flusso di input non corrisponde, mwzwscanf termina;
• Specifiche di formato introdotte dal segno di percentuale (mw0q%). Una specifica di formato determina la lettura e la conversione dei caratteri nell'input in un valore di un tipo specificato. Il valore viene assegnato a un argomento nell'elenco degli argomenti.
I definitori di formato (format specifier)
Una specifica di formato presenta la forma seguentecite-ref-7[7]:
%[*][ampiezza][{h|l|L}]tipo
Come accade anche nella funzione mw2gprintf, gli argomenti tra parentesi possono essere omessi a seconda delle esigenze.
La mw3aampiezza è un numero intero positivo che controlla il numero massimo di caratteri da leggere da stdin per quella specifica di formato.
Il carattere di soppressione dell'assegnazione (mw3g*) serve a leggere un valore dall'input e a ignorarlo, senza pertanto assegnarlo a una variabile.
Nella tabella seguente sono mostrati i tipi di datocite-ref-8[8] da poter inserire:
| | Descrizione |
|---|---|
| c | Carattere singolo ASCII (non solo quelli stampabili) |
| i | Numero intero |
| d | Numero intero decimale |
| u | Numero intero decimale senza segno |
| o | Numero intero ottale senza segno |
| x | Numero intero esadecimale senza segno |
| f | Numero reale a singola precisione (float) |
| a | Numero reale (float) in notazione esadecimale (presente dal C99) |
| e | Numero reale in virgola mobile in notazione scientifica [-]d.ddde±dd |
| g | Numero reale in notazione estesa (f) e in notazione scientifica (e) |
| s | Stringa (array di caratteri e, poiché già puntatore, nella scanf non ha bisogno di '&') |
| p | Indirizzo di memoria (puntatore) |
| [ set ] | Lista di caratteri (si blocca appena incontra un carattere non presente nella lista) |
| n | nessun input letto dal buffer |
| l | Modificatore di lunghezza (long) |
| L | Modificatore di lunghezza (long long) |
| h | Modificatore di lunghezza (short) |
| % | Solo il carattere di percentuale |
Una differenza che si ritrova con la funzione mwasqprintf sta nell'utilizzo dei definitori mwasu%i, mwasy%d, mwasc%u, mwasg%o, e mwask%x, in particolare per mwaso%i e mwass%d perché sono sinonimi per l'output, ma diversi se usati per l'input. Bisogna pertanto fare attenzione al tipo di numero intero fornito. Mentre %i è in grado di riconoscere una base mwaswdecimale da una mwas0ottale e da una mwas4esadecimale (rispettivamente tramite l'uso del prefisso 0 e 0x), in tutti gli altri casi si sta definendo a prescindere una base specifica e un eventuale segnocite-ref-9[9].
Il definitore mwatq%l (long, cioè lunghezza doppia) viene sempre seguito da altri definitori per indicare che lo spazio di memoria necessario da allocare (fa unica eccezione mwatup perché, in quanto già mwatyindirizzo di memoria, non ha bisogno di una ulteriore specifica di formato). Pertanto, ad esempio, mwatc%lf indicherà un numero reale a doppia precisione (mwatgdouble), mentre mwatk%lu indicherà un numero intero decimale senza segno a mwato64 bit (invece degli usuali mwats32 bit).
Il definitore mwat0%h (short, cioè mezza lunghezza) si antepone solo per i definitori di numeri interi. Pertanto, ad esempio, mwat4%hi indicherà un numero intero a 16 bit.
Il definitore mwaua%L si antepone ai numeri reali in virgola mobile (es. mwaue%Lf) per indicare i formati long double.
Il definitore mwaum%g ha la proprietà di poter leggere i numeri in virgola mobile sia del formato mwauq%f, che del formato mwauu%e. Proprietà che nella funzione mwauyprintf si traduce nel poter restituire il formato che si presenta più corto tra i due.
Il definitore mwaug%n punta a un tipo di dato int, in cui viene memorizzato il numero di caratteri letti correttamente dallo stream o dal buffer fino a quel punto nella chiamata a mwaukscanf().
Il definitore mwaus%p ha la particolarità di dover puntare a un puntatore che è stato dichiarato, o per lo meno convertito, come mwauwvoid.
Per l'uso degli insiemi di caratteri (mwau4[]), si può mwau8complementarizzare tramite l'insieme di caratteri scelti: se il primo carattere nell'insieme è un accento circonflesso (mwava^), l'effetto viene invertito e il campo di input viene letto fino al primo carattere che appartiene nel resto dell'insieme di caratteri (operando a tutti gli effetti l'operazione mwaveXOR).
Il definitore mwavm%% corrisponde al solo carattere di percentuale (%).cite-ref-10[10]
Valore restituito
La funzione mwavoscanf() restituisce il numero (int) di campi che sono stati convertiti e assegnati correttamente. Il mwavsvalore di ritorno non comprende il numero di campi che sono stati letti, ma non assegnati.
Il valore di ritorno è negativo, EOF (end of file), per un tentativo di lettura alla fine del file, se non è stata eseguita alcuna conversione. Un valore di ritorno 0 (zero) indica che non sono stati assegnati campi.cite-ref-11[11]
Condizioni di errore
Se il tipo di argomento a cui deve essere assegnato è diverso dalla specifica di formato, possono verificarsi risultati imprevedibili. Ad esempio, la lettura di un valore a virgola mobile, ma l'assegnazione in una variabile di tipo int, non è corretta e avrebbe risultati imprevedibili.
Se ci sono più argomenti che specifiche di formato, gli argomenti supplementari vengono ignorati. I risultati non sono definiti se non vi sono argomenti sufficienti per le specifiche di formato.
Se la stringa di formato contiene una specifica di formato non valida e vengono utilizzate specifiche di formato posizionali, errno verrà impostato su EILSEQ.
Se vengono utilizzate specifiche di formato posizionale e non vi sono argomenti sufficienti, errno verrà impostato su EINVAL.
Se si verifica un errore di conversione, errno può essere impostato su ECONVERT.cite-ref-12[12]
Overflow aritmetico
Durante la conversione da stringa a numero (come con mwaw0atoi, mwaw4atol e mwaw8atof) vi è il problema per cui la funzione mwaxascanf non riesce a determinare un mwaxeoverflow aritmetico (allo stesso modo di un underflow aritmetico nel caso dei numeri in virgola mobile). Perciò viene sconsigliato l'uso di questi convertitori per qualsiasi software applicativo che richieda controlli stringenti sull'input.
Come alternativa si indicano le funzioni mwaxmstrtol e mwaxqstrtod, che effettuano dei controlli aggiuntivi sull'overflow/underflow.
Funzioni derivate
fscanf
La funzione mwaymfscanf legge i dati di input da un file, piuttosto che utilizzare l'input standard. Il suo funzionamento è sostanzialmente uguale a quello della sua primitiva e il suo prototipo (in C/C++) è:
int fscanf (FILE *file, const char *format, ...); // fino a C99
int fscanf (FILE *restrict file, const char *restrict format, ...); //dal C99
sscanf
La funzione mwabksscanf legge i dati di input da un buffer, piuttosto che utilizzare l'input standard, restituendo i valori che si possono leggere, e il suo prototipo (in C/C++) è:
int sscanf (char *buffer, const char *format, ...); // fino a C99
int sscanf (char *restrict buffer, const char *restrict format, ...); //dal C99
Altre funzioni derivate
Dal C11 sono state introdotte ulteriori funzioni: mwae8scanf_s, mwafafscanf_s, mwafesscanf_s.
Esempi d'uso
#include <stdio.h>
int main(void)
{
int i;
float fp;
char c, s[81];
printf("Inserire un numero intero, un numero reale,"
" un carattere e una stringa: \n");
if (scanf("%d %f %c %s", &i, &fp, &c, s) != 4)
printf("Non tutti i campi sono stati compilati\n");
else
{
printf("numero intero = %d\n", i);
printf("numero reale = %f\n", fp);
printf("carattere = %c\n", c);
printf("stringa = %s\n",s);
}
}
Se l'input è mwape27 5.4 t si, allora l'uotput sarà simile a:
Inserire un numero intero, un numero reale, un carattere e una stringa:
numero intero = 27
numero reale = 5.400000
carattere = t
stringa = si
Uso dell'indicatore d'ampiezza
#include <stdio.h>
int main()
{
int i;
float x, y;
char name[50];
printf ("Inserire due stringhe numeriche che contengano 8 caratteri"
" ognuna e che abbiano entrambe un punto al centro:\n");
scanf("%2d %f %6f %[0123456789]", &i, &x, &y, name);
printf("numero intero = %d\n", i);
printf("primo numero reale = %f\n", x);
printf("secondo numero reale = %f\n", y);
printf("il resto della stringa = %s\n",name);
}
Se l'input è mwawo1234.4321 1234.4321, allora l'output sarà simile a
Inserire due stringhe numeriche che contengano almeno 8 caratteri ognuna e che abbiano entrambe un punto al centro:
numero intero = 12
primo numero reale = 34.432098
secondo numero reale = 1234.400024
resto della stringa = 321
Come si può notare, l'uso di uno definitore di virgola mobile permette la lettura del punto di separazione decimale, ma bisogna contare anche la lettura del punto perché è esso stesso un carattere (il 24 in coda al secondo numero reale è solo un errore di conversione mwaw8binaria dei numeri decimali).
Uso in un ciclo
#include <stdio.h>
int main()
{
int numero;
printf("Inserire un numero esadecimale o qualunque altra cosa diversa per uscire:\n");
while (scanf("%x",&numero))
{
printf("Numero esadecimale = %x\n",numero);
printf("Numero decimale = %d\n",numero);
}
}
Questo esempio converte un numero intero esadecimale in un numero intero decimale. Il mwa1yloop mwa1cwhile termina se il valore di input non è un numero intero esadecimale. Se l'input è mwa1g0x231 0xf5e 0xmwa1k1 0x, allora l'output sarà simile a
Inserire un numero esadecimale o qualunque altra cosa diversa per uscire:
Numero esadecimale = 231
Numero decimale = 561
Numero esadecimale = f5e
Numero decimale = 3934
Numero esadecimale = 1
Numero decimale = 1
Numero esadecimale = 0
Numero decimale = 0
Uso del soppressore d'assegnazione (*)
#include <stdio.h>
int main()
{
char text[20];
float number;
printf("Inserire i dati:\n");
scanf("%s %*d %f", text, &number);
printf("output: %s %f\n", text, number);
return 0;
}
Al momento di leggere la stringa, mwa6yscanf non leggerà ciò che corrisponde a mwa6c%*d, pertanto non c'è bisogno di assegnare l'indirizzo di un argomento per tale corrispondenza.cite-ref-15[15] Pertanto, per un input del tipo mwa6wprova 324.523, si otterrà un output del tipo:
Inserire i dati:
output: prova 0.523000
Uso dei puntatori
#include <stdio.h>
int main()
{
int val = 123;
char buf[100];
sprintf(buf, "%p", (void*)&val);
printf("Original =%s\n", buf);
void *ptr;
sscanf(buf, "%p", &ptr);
printf("Read back=%p\n", ptr);
int *iPtr = ptr;
if (iPtr == &val) {
printf("Pointers match\n");
}
}
La funzione mwbdmsprintf alla riga 3 scrive il puntatore nel buffer di output; mwbdqsscanf lo rilegge.
Alla riga 6, la stringa immessa in mwbdysscanf corrisponde esattamente alla stringa prodotta da mwbdcsprintf, quindi lo standard garantisce che mwbdgiPtr == &val verrà valutato come mwbdktrue e il comportamento sia pertanto definito. Passare una stringa che non corrisponde a nulla di ciò che è stato prodotto dallo stesso programma in esecuzione sarebbe un comportamento indefinito.cite-ref-16[16]
Vulnerabilità
mwbeascanf è vulnerabile ai mwbeeformat string attackscite-ref-17[17]. Bisogna pertanto prestare grande cura nell'assicurarsi che la stringa di formattazione contenga delle limitazioni riguardo la grandezza degli array (e quindi anche delle stringe) che vengono passati. In molti casi è arbitraria la grandezza della stringa inserita dall'utente e non può essere determinata prima che mwbeyscanf venga eseguita. Ciò significa che i definitori di formato usati senza un limitatore di lunghezza sono intrinsecamente non sicuri e sfruttabili tramite mwbecbuffer overflows.
Un'ulteriore vulnerabilità riguarda il permesso ad usare stringhe di formato dinamiche (dynamic formatting stringscite-ref-18[18]), per esempio stringhe di formattazione contenute in file di configurazione o altri file accessibili dall'utente e di cui ne detenga i mwbe0permessi di modifica. Un attacco noto che sfrutta questo genere di vulnerabilità è mwbe4SQL injection.
Per questi ed altri motivi, ad oggi mwbfascanf viene messa in secondo piano durante l'apprendimento del C/C++, propendendo piuttosto verso mwbfefgets per l'acquisizione della riga, per poi passare la stessa a mwbfisscanf per scomporla (entrambe funzioni anch'esse contenute all'interno di mwbfmstdio.h).cite-ref-19[19]
Note
cite-note-11. ↑ mwbf4(mwbf8mwbgaEN) mwbgemwbgiThe Basics of C Programming, su mwbgmHowStuffWorks, 1º aprile 2000. mwbgqURL consultato il 14 novembre 2025.
cite-note-22. ↑ mwbggmwbgkmwbgoMichael Lesk's Home Page, su mwbgslesk.com. mwbgwURL consultato il 14 novembre 2025.
cite-note-33. ↑ mwbhamwbhemwbhirestrict type qualifier (since C99) - cppreference.com, su mwbhmen.cppreference.com. mwbhqURL consultato il 14 novembre 2025.
cite-note-44. ↑ mwbhgmwbhkmwbhoC Input/Output: printf() and scanf(), su mwbhswww.programiz.com. mwbhwURL consultato il 14 novembre 2025.
cite-note-55. ↑ mwbiamwbiemwbiiscanf, fscanf, sscanf, scanf_s, fscanf_s, sscanf_s - cppreference.com, su mwbimen.cppreference.com. mwbiqURL consultato l'11 novembre 2025.
cite-note-66. ↑ mwbig(mwbikmwbioIT) mwbisBrian W. Kerninghan e mwbiwDennis M. Ritchie, mwbi07, in mwbi4Il linguaggio C mwbi8[mwbjaThe C programming languagemwbje], traduzione di Valerio Marra, Revisore: Vincenzo Marra, seconda edizione, Pearson, 2007, p.mwbji 161, mwbjmISBNmwbjq 9788891908230.
cite-note-77. ↑ mwbjkTylerMSFT, mwbjomwbjsCampi per la specifica di formato: funzioni scanf e wscanf, su mwbjwlearn.microsoft.com. mwbj0URL consultato il 14 novembre 2025.
cite-note-88. ↑ mwbkemwbkimwbkmFundamental types - cppreference.com, su mwbkqen.cppreference.com. mwbkuURL consultato il 14 novembre 2025.
cite-note-99. ↑ mwbkkmwbkomwbksArithmetic types - cppreference.com, su mwbkwen.cppreference.com. mwbk0URL consultato il 14 novembre 2025.
cite-note-1010. ↑ mwblemwblimwblmfscanf, su mwblqpubs.opengroup.org. mwbluURL consultato il 14 novembre 2025.
cite-note-1111. ↑ mwblk(mwblomwblsEN) mwblwmwbl0scanf in C, su mwbl4GeeksforGeeks, 24 giugno 2022. mwbl8URL consultato il 14 novembre 2025.
cite-note-1212. ↑ mwbmmmwbmqmwbmuscanf () - Leggi dati, su mwbmywww.ibm.com. mwbmcURL consultato il 14 novembre 2025.
cite-note-1313. ↑ mwbmsmwbmwmwbm0Che cos'è l'analisi statica del codice? - Software Check Point, su mwbm4Check Point Software. mwbm8URL consultato il 14 novembre 2025.
cite-note-1414. ↑ mwbnmmwbnqmwbnuclang-tidy - bugprone-unchecked-string-to-number-conversion — Extra Clang Tools 22.0.0git documentation, su mwbnyclang.llvm.org. mwbncURL consultato il 14 novembre 2025.
cite-note-1515. ↑ mwbns(mwbnwmwbn0EN) mwbn4mwbn8Assignment Suppression Character, su mwboaStack Overflow. mwboeURL consultato il 14 novembre 2025.
cite-note-1616. ↑ mwbou(mwboymwbocEN) mwbogmwbokUsing scanf %p UB, su mwbooStack Overflow. mwbosURL consultato il 14 novembre 2025.
cite-note-1717. ↑ mwbo8(mwbpamwbpeEN) mwbpimwbpmFormat string attack | OWASP Foundation, su mwbpqowasp.org. mwbpuURL consultato l'11 novembre 2025.
cite-note-1818. ↑ mwbpk(mwbpomwbpsEN) mwbpwmwbp0Introducing dynamic format strings for DAX measures - SQLBI, su mwbp4sqlbi.com. mwbp8URL consultato l'11 novembre 2025.
cite-note-1919. ↑ mwbqm(mwbqqmwbquEN) mwbqymwbqcVulnerability using printf/scanf and %s, su mwbqgStack Overflow. mwbqkURL consultato il 14 novembre 2025.
Voci correlate